import java.util.*;


class MinStack {
    Stack<Integer> stack=null;
    Stack<Integer> minStack=null;
    public MinStack() {
        stack=new Stack<>();
        minStack=new Stack<>();
    }

    public void push(int val) {
        if(minStack.empty()){
            minStack.push(val);
        }else if(minStack.peek()>=val){
            minStack.push(val);
        }
        stack.push(val);
    }

    public void pop() {
        int val=stack.pop();
        if(minStack.peek()==val){
            minStack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minStack.peek();
    }
}









class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    public MyStack() {
        queue1=new ArrayDeque<>();
        queue2=new ArrayDeque<>();
    }

    public void push(int x) {
        if(this.empty()){
            queue1.offer(x);
        }else if(!queue1.isEmpty()){
            queue1.offer(x);
        }else {
            queue2.offer(x);
        }
    }

    public int pop() {
        if(this.empty()){
            return -1;
        }
        if(!this.queue1.isEmpty()){
            int size=queue1.size();
            for(int i=0;i<size-1;i++){
                queue2.offer(queue1.poll());
            }
            return queue1.poll();
        }else{
            int size=queue2.size();
            for(int i=0;i<size-1;i++){
                queue1.offer(queue2.poll());
            }
            return queue2.poll();
        }
    }

    public int top() {
        if(this.empty()){
            return -1;
        }
        if(!this.queue1.isEmpty()){
            int size=queue1.size();
            int tmp=-1;
            for(int i=0;i<size;i++){
                tmp=queue1.poll();
                queue2.offer(tmp);
            }
            return tmp;
        }else{
            int tmp=-1;
            int size=queue2.size();
            for(int i=0;i<size;i++){
                tmp=queue2.poll();
                queue1.offer(tmp);
            }
            return tmp;
        }
    }

    public boolean empty() {
        return queue2.isEmpty()&& queue1.isEmpty();
    }
}








class MyQueue {
    Stack<Integer> stack1=null;
    Stack<Integer> stack2=null;
    public MyQueue() {
        stack1=new Stack<>();
        stack2=new Stack<>();
    }

    public void push(int x) {
        stack1.push(x);
    }

    public int pop() {
        if(this.empty()){
            return -1;
        }
        if(this.stack2.empty()){
            while (!this.stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }

    public int peek() {
        if(this.empty()){
            return -1;
        }
        if(this.stack2.empty()){
            while (!this.stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }

    public boolean empty() {
        return stack1.empty()&&stack2.empty();
    }
}












class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
public class project {
    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {

    }














    public static void main(String[] args) {
        boolean b=true?false:true==true?false:true;
        System.out.println(b);

    }
    public static int add(int a){
        try {
            a+=10;
            return a;
        }catch (RuntimeException e){

        }catch (Exception e2){

        }finally {
            a+=10;
            return a;
        }
    }










    public int removePalindromeSub(String s) {
        if(s.equals(" ")){
            return 0;
        }
        if(s.equals(new StringBuffer(s).reverse().toString())){
            return 1;
        }
        return 2;
    }

















    public boolean isValid(String s) {
        Stack<Character> stack=new Stack<>();
        for(char ch : s.toCharArray()){
            if(ch=='('||ch=='{'||ch=='['){
                stack.push(ch);
            }else{
                if(stack.empty()){
                    return false;
                }
                char stackPeek=stack.peek();
                if(stackPeek=='('&&ch==')'||
                stackPeek=='{'&&ch=='}'||
                stackPeek=='['&&ch==']'){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        if(!stack.empty()){
            return false;
        }
        return true;
    }


















    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int len1=nums1.length;
        int len2=nums2.length;
        int[] nums=new int[len1];
        if(len1==0){
            return nums;
        }
        for(int i=0;i<len1;i++){
            int val=nums1[i];
            int j=0;
            while (j<len2&&nums2[j]!=val){
                j++;
            }
            j++;
            while (j<len2&&nums2[j]<val){
                j++;
            }
            if(j==len2){
                nums[i]=-1;
                continue;
            }
            nums[i]=nums2[j];
        }
        return nums;
    }
















    public List<String> buildArray(int[] target, int n) {
        List<String> list=new ArrayList<>();
        int index=1;
        for (int t : target){
            while (index!=t){
                list.add("Push");
                list.add("Pop");
                index++;
            }
            index++;
            list.add("Push");
        }
        return list;
    }
}
